M

MLOG

Deutsch

Entdecken Sie Solidity, die führende Sprache für Smart Contracts auf Ethereum. Dieser Leitfaden behandelt Grundlagen und fortgeschrittene Techniken.

Solidity: Ein umfassender Leitfaden zur Smart-Contract-Programmierung

Solidity ist eine hochrangige, vertragsorientierte Programmiersprache, die zur Implementierung von Smart Contracts auf verschiedenen Blockchain-Plattformen, insbesondere Ethereum, verwendet wird. Sie ist stark von C++, Python und JavaScript beeinflusst und darauf ausgelegt, die Ethereum Virtual Machine (EVM) anzusprechen. Dieser Leitfaden bietet einen detaillierten Überblick über Solidity, geeignet für Anfänger und erfahrene Programmierer, die in die Welt der Blockchain-Entwicklung eintauchen möchten.

Was sind Smart Contracts?

Bevor wir uns mit Solidity befassen, ist es wichtig zu verstehen, was Smart Contracts sind. Ein Smart Contract ist ein selbstausführender Vertrag, dessen Bedingungen direkt im Code niedergeschrieben sind. Er wird auf einer Blockchain gespeichert und automatisch ausgeführt, wenn vorab festgelegte Bedingungen erfüllt sind. Smart Contracts ermöglichen Automatisierung, Transparenz und Sicherheit in verschiedenen Anwendungen, darunter:

Warum Solidity?

Solidity ist die dominierende Sprache zum Schreiben von Smart Contracts auf Ethereum und anderen EVM-kompatiblen Blockchains, was auf mehrere Faktoren zurückzuführen ist:

Einrichtung Ihrer Entwicklungsumgebung

Um mit der Entwicklung in Solidity zu beginnen, müssen Sie eine geeignete Entwicklungsumgebung einrichten. Hier sind einige beliebte Optionen:

Remix IDE

Remix ist eine online, browserbasierte IDE, die sich perfekt zum Lernen und Experimentieren mit Solidity eignet. Sie erfordert keine lokale Installation und bietet Funktionen wie:

Greifen Sie auf die Remix IDE unter https://remix.ethereum.org/ zu

Truffle Suite

Truffle ist ein umfassendes Entwicklungs-Framework, das den Prozess des Erstellens, Testens und Bereitstellens von Smart Contracts vereinfacht. Es bietet Tools wie:

Zur Installation von Truffle:

npm install -g truffle

Hardhat

Hardhat ist eine weitere beliebte Ethereum-Entwicklungsumgebung, bekannt für ihre Flexibilität und Erweiterbarkeit. Es ermöglicht Ihnen, Ihren Solidity-Code zu kompilieren, bereitzustellen, zu testen und zu debuggen. Zu den Hauptfunktionen gehören:

Zur Installation von Hardhat:

npm install --save-dev hardhat

Grundlagen von Solidity: Syntax und Datentypen

Lassen Sie uns die grundlegende Syntax und die Datentypen in Solidity erkunden.

Struktur eines Solidity-Vertrags

Ein Solidity-Vertrag ähnelt einer Klasse in der objektorientierten Programmierung. Er besteht aus Zustandsvariablen, Funktionen und Ereignissen. Hier ist ein einfaches Beispiel:

pragma solidity ^0.8.0;

contract SimpleStorage {
 uint256 storedData;

 function set(uint256 x) public {
 storedData = x;
 }

 function get() public view returns (uint256) {
 return storedData;
 }
}

Erklärung:

Datentypen

Solidity unterstützt eine Vielzahl von Datentypen:

Beispiel:

pragma solidity ^0.8.0;

contract DataTypes {
 uint256 public age = 30;
 bool public isAdult = true;
 address public owner = 0x5B38Da6a701c568545dCfcB03FcB875f56beddC4;
 bytes32 public name = "JohnDoe";
 uint[] public numbers = [1, 2, 3, 4, 5];
 mapping(address => uint) public balances;

 constructor() {
 balances[msg.sender] = 100;
 }
}

Zustandsvariablen vs. Lokale Variablen

Zustandsvariablen werden außerhalb von Funktionen deklariert und auf der Blockchain gespeichert. Sie bleiben über Funktionsaufrufe und Vertragsausführungen hinweg erhalten. Im obigen Beispiel ist storedData eine Zustandsvariable.

Lokale Variablen werden innerhalb von Funktionen deklariert und existieren nur innerhalb des Gültigkeitsbereichs dieser Funktion. Sie werden nicht auf der Blockchain gespeichert und verworfen, wenn die Funktion abgeschlossen ist.

Funktionen in Solidity

Funktionen sind die Bausteine von Smart Contracts. Sie definieren die Logik und Operationen, die der Vertrag ausführen kann. Funktionen können:

Funktionssichtbarkeit

Solidity-Funktionen haben vier Sichtbarkeitsmodifikatoren:

Funktionsmodifikatoren

Funktionsmodifikatoren werden verwendet, um das Verhalten einer Funktion zu ändern. Sie werden oft verwendet, um Sicherheitsbeschränkungen durchzusetzen oder Prüfungen durchzuführen, bevor die Logik der Funktion ausgeführt wird.

Beispiel:

pragma solidity ^0.8.0;

contract Ownership {
 address public owner;

 constructor() {
 owner = msg.sender;
 }

 modifier onlyOwner() {
 require(msg.sender == owner, "Only owner can call this function");
 _;
 }

 function transferOwnership(address newOwner) public onlyOwner {
 owner = newOwner;
 }
}

In diesem Beispiel prüft der Modifikator onlyOwner, ob der Aufrufer der Eigentümer des Vertrags ist. Falls nicht, wird die Transaktion zurückgesetzt. Der Platzhalter _ repräsentiert den Rest des Funktionscodes.

Funktionszustandsmutabilität

Solidity-Funktionen können auch Zustandsmutabilitätsmodifikatoren haben:

Beispiel:

pragma solidity ^0.8.0;

contract Example {
 uint256 public value;

 function getValue() public view returns (uint256) {
 return value;
 }

 function add(uint256 x) public pure returns (uint256) {
 return x + 5;
 }

 function deposit() public payable {
 value += msg.value;
 }
}

Kontrollstrukturen

Solidity unterstützt Standard-Kontrollstrukturen wie if, else, for, while und do-while Schleifen.

Beispiel:

pragma solidity ^0.8.0;

contract ControlStructures {
 function checkValue(uint256 x) public pure returns (string memory) {
 if (x > 10) {
 return "Value is greater than 10";
 } else if (x < 10) {
 return "Value is less than 10";
 } else {
 return "Value is equal to 10";
 }
 }

 function sumArray(uint[] memory arr) public pure returns (uint256) {
 uint256 sum = 0;
 for (uint256 i = 0; i < arr.length; i++) {
 sum += arr[i];
 }
 return sum;
 }
}

Ereignisse und Protokollierung

Ereignisse ermöglichen Smart Contracts die Kommunikation mit der Außenwelt. Wenn ein Ereignis ausgelöst wird, wird es in den Transaktionsprotokollen der Blockchain gespeichert. Diese Protokolle können von externen Anwendungen überwacht werden, um die Aktivität des Vertrags zu verfolgen.

Beispiel:

pragma solidity ^0.8.0;

contract EventExample {
 event ValueChanged(address indexed caller, uint256 newValue);

 uint256 public value;

 function setValue(uint256 newValue) public {
 value = newValue;
 emit ValueChanged(msg.sender, newValue);
 }
}

In diesem Beispiel wird das Ereignis ValueChanged immer dann ausgelöst, wenn die Funktion setValue aufgerufen wird. Das Schlüsselwort indexed beim Parameter caller ermöglicht externen Anwendungen, Ereignisse basierend auf der Adresse des Aufrufers zu filtern.

Vererbung

Solidity unterstützt Vererbung, wodurch Sie neue Verträge basierend auf bestehenden erstellen können. Dies fördert die Wiederverwendung von Code und Modularität.

Beispiel:

pragma solidity ^0.8.0;

contract BaseContract {
 uint256 public value;

 function setValue(uint256 newValue) public {
 value = newValue;
 }
}

contract DerivedContract is BaseContract {
 function incrementValue() public {
 value++;
 }
}

In diesem Beispiel erbt der DerivedContract vom BaseContract. Er erbt die Zustandsvariable value und die Funktion setValue. Er definiert auch seine eigene Funktion, incrementValue.

Bibliotheken

Bibliotheken ähneln Verträgen, können aber keine Daten speichern. Sie werden verwendet, um wiederverwendbaren Code bereitzustellen, der von mehreren Verträgen aufgerufen werden kann. Bibliotheken werden nur einmal bereitgestellt, was die Gaskosten senkt.

Beispiel:

pragma solidity ^0.8.0;

library Math {
 function add(uint256 a, uint256 b) internal pure returns (uint256) {
 return a + b;
 }
}

contract Example {
 using Math for uint256;
 uint256 public result;

 function calculateSum(uint256 x, uint256 y) public {
 result = x.add(y);
 }
}

In diesem Beispiel definiert die Math-Bibliothek eine add-Funktion. Die Anweisung using Math for uint256; ermöglicht es Ihnen, die add-Funktion auf uint256-Variablen unter Verwendung der Punktnotation aufzurufen.

Häufige Smart-Contract-Schwachstellen

Smart Contracts sind anfällig für verschiedene Schwachstellen, die zu Geldeinbußen oder unerwartetem Verhalten führen können. Es ist entscheidend, sich dieser Schwachstellen bewusst zu sein und Maßnahmen zu deren Minderung zu ergreifen.

Reentrancy (Wiederkehraufruf)

Reentrancy tritt auf, wenn ein Vertrag einen externen Vertrag aufruft und der externe Vertrag den ursprünglichen Vertrag erneut aufruft, bevor die Ausführung des ursprünglichen Vertrags abgeschlossen ist. Dies kann zu unerwarteten Zustandsänderungen führen.

Minderung: Verwenden Sie das Checks-Effects-Interactions-Muster und erwägen Sie die Verwendung der Funktionen transfer oder send, um das für den externen Aufruf verfügbare Gas zu begrenzen.

Überlauf und Unterlauf

Ein Überlauf tritt auf, wenn eine arithmetische Operation den Maximalwert eines Datentyps überschreitet. Ein Unterlauf tritt auf, wenn eine arithmetische Operation zu einem Wert führt, der kleiner ist als der Minimalwert eines Datentyps.

Minderung: Verwenden Sie SafeMath-Bibliotheken (obwohl ab Solidity 0.8.0 Überlauf- und Unterlaufprüfungen standardmäßig integriert sind), um diese Probleme zu verhindern.

Zeitstempel-Abhängigkeit

Die Abhängigkeit vom Blockzeitstempel (block.timestamp) kann Ihren Vertrag anfällig für Manipulationen durch Miner machen, da diese eine gewisse Kontrolle über den Zeitstempel haben.

Minderung: Vermeiden Sie die Verwendung von block.timestamp für kritische Logik. Erwägen Sie die Verwendung von Orakeln oder anderen zuverlässigeren Zeitquellen.

Denial of Service (DoS)

DoS-Angriffe zielen darauf ab, einen Vertrag für legitime Benutzer unbrauchbar zu machen. Dies kann durch das Verbrauchen des gesamten verfügbaren Gases oder durch das Ausnutzen von Schwachstellen erreicht werden, die dazu führen, dass der Vertrag zurückgesetzt wird.

Minderung: Implementieren Sie Gaslimits, vermeiden Sie Schleifen mit unbegrenzten Iterationen und validieren Sie Benutzereingaben sorgfältig.

Front Running

Front Running tritt auf, wenn jemand eine ausstehende Transaktion beobachtet und eine eigene Transaktion mit einem höheren Gaspreis einreicht, um diese vor der ursprünglichen Transaktion ausführen zu lassen.

Minderung: Verwenden Sie Commit-Reveal-Schemata oder andere Techniken, um Transaktionsdetails zu verbergen, bis sie ausgeführt wurden.

Best Practices für das Schreiben sicherer Smart Contracts

Fortgeschrittene Solidity-Konzepte

Sobald Sie ein solides Verständnis der Grundlagen haben, können Sie fortgeschrittenere Konzepte erkunden:

Assembler

Solidity ermöglicht es Ihnen, Inline-Assembler-Code zu schreiben, was Ihnen mehr Kontrolle über die EVM gibt. Dies erhöht jedoch auch das Risiko, Fehler und Schwachstellen einzuführen.

Proxies

Proxies ermöglichen es Ihnen, Ihre Smart Contracts zu aktualisieren, ohne Daten zu migrieren. Dies beinhaltet die Bereitstellung eines Proxy-Vertrags, der Aufrufe an einen Implementierungsvertrag weiterleitet. Wenn Sie den Vertrag aktualisieren möchten, stellen Sie einfach einen neuen Implementierungsvertrag bereit und aktualisieren den Proxy, um auf die neue Implementierung zu verweisen.

Meta-Transaktionen

Meta-Transaktionen ermöglichen es Benutzern, mit Ihrem Smart Contract zu interagieren, ohne direkt Gasgebühren zu zahlen. Stattdessen zahlt ein Relayer die Gasgebühren in ihrem Namen. Dies kann die Benutzerfreundlichkeit verbessern, insbesondere für Benutzer, die neu in der Blockchain sind.

EIP-721 und EIP-1155 (NFTs)

Solidity wird häufig verwendet, um Non-Fungible Tokens (NFTs) unter Verwendung von Standards wie EIP-721 und EIP-1155 zu erstellen. Das Verständnis dieser Standards ist entscheidend für den Aufbau NFT-basierter Anwendungen.

Solidity und die Zukunft der Blockchain

Solidity spielt eine entscheidende Rolle in der sich schnell entwickelnden Landschaft der Blockchain-Technologie. Da die Akzeptanz der Blockchain weiter zunimmt, werden Solidity-Entwickler sehr gefragt sein, um innovative und sichere dezentrale Anwendungen zu entwickeln. Die Sprache wird ständig aktualisiert und verbessert, daher ist es für den Erfolg in diesem Bereich unerlässlich, mit den neuesten Entwicklungen Schritt zu halten.

Fazit

Solidity ist eine mächtige und vielseitige Sprache für den Aufbau von Smart Contracts auf der Ethereum-Blockchain. Dieser Leitfaden hat einen umfassenden Überblick über Solidity gegeben, von grundlegenden Konzepten bis zu fortgeschrittenen Techniken. Durch das Beherrschen von Solidity und das Befolgen bewährter Praktiken für eine sichere Entwicklung können Sie zur spannenden Welt dezentraler Anwendungen beitragen und die Zukunft der Blockchain-Technologie mitgestalten. Denken Sie daran, Sicherheit immer zu priorisieren, Ihren Code gründlich zu testen und über die neuesten Entwicklungen im Solidity-Ökosystem informiert zu bleiben. Das Potenzial von Smart Contracts ist immens, und mit Solidity können Sie Ihre innovativen Ideen zum Leben erwecken.

Solidity: Ein umfassender Leitfaden zur Smart-Contract-Programmierung | MLOG